// 设置参数默认值
// function sayHi() {
//   // console.log(arguments);
//   let sum = 0;
//   for (let i = 0; i < arguments.length; i++) {
//     sum += arguments[i];
//   }
//   return sum;
//   // document.write(`<p>⼤家好，我叫${arguments[0]}，我今年${arguments[1]}岁了。</p>`);
// }

// console.log(sayHi(1, 2, 3));
//  // 调⽤函数
// sayHi();
// // sayHi('⼩红');
// sayHi('⼩刚', 21);
// sayHi(undefined, 21);

// 剩余参数
// function config(kkk, ...args) {
//   console.log(kkk) // 得到 'http://baidu.com'
//   console.log(args) // other 得到 ['get', 'json']
//   console.log(args[0]) // get
// }
//  // 调⽤函数
//  config('http://baidu.com', 'get', 'json');

// 箭头函数只有一个传参可以不写圆括号，函数语句只有一句可以不写花括号
// const fn = () => {
//   console.log(123);
// };
// fn();

// // 只有一个传参的简写方式
// const fn1 = x => {
//   console.log(123);
// };

// const fn2 = (x,y) => x+y
// // const fn2 = (x,y) => {return x+y}
// // console.log(fn2(1,2))

// const fn3 = (uname) => ({ uname: uname })
//  console.log(fn3('刘德华'))

// let arr = [
//   {a:1, b:6},
//   {a:2, b:8},
//   {a:4, b:6},
// ]
// let newArr = arr.map((item, index, arr) => {
//   return item.a + item.b==10 ? '正确' : '错误'
// })
// console.log(newArr)

// // 1. 利⽤箭头函数来求和
// const getSum = (a, b, ...arr) => {
//   // console.log(arguments) // 报错，箭头函数没有arguments
//   let sum = 0;
//   for (let i = 0; i < arr.length; i++) {
//     sum += arr[i];
//   }
//   return sum+a+b;
// };
// const result = getSum(2, 3, 4, 6, 9, 7);
// console.log(result);

//  2. 箭头函数的this 是上⼀层作⽤域的this 指向
// const fn = () => {
//   console.log(this); // window
// };
// fn();

// // 对象⽅法箭头函数 this
// const obj = {
//   uname: "ssss⽼师",
//   sayHi: () => {
//     console.log(this); // this 指向谁？ window
//   },
// };
// obj.sayHi();

// const obj = {
//   uname: "ssss⽼师",
//   sayHi: function () {
//     console.log(this); // obj
//     let i = 10;
//     const count = () => {
//       console.log(this); // obj
//     };
//     count();
//   },
// };
// obj.sayHi();

// Object.entries(obj)
// let arr = [
//   ["a", 1],
//   ["b", 2],
//   ["c", 3],
// ];
// for ([a, b] of arr) {
//   console.log(item[0], item[1]);
// }

// 普通的数组
// let arr = [1, 2, 3];
// // 批量声明变量 a b c
// // 同时将数组单元值 1 2 3 依次赋值给变量 a b c
// let [a, b, c] = arr;
// console.log(a); // 1
// console.log(b); // 2
// console.log(c); // 3

// let obj = { a: 1, b: 2 };
// const { a, b } = obj;
// console.log(a, b);

// const msg = {
//   code: 200,
//   msg1: "获取新闻列表成功",
//   data: [
//     {
//       id: 1,
//       title: "5G商⽤⾃⼰，三⼤运⽤商收⼊下降",
//       count: 58,
//     },
//     {
//       id: 2,
//       title: "国际媒体头条速览",
//       count: 56,
//     },
//     {
//       id: 3,
//       title: "乌克兰和俄罗斯持续冲突",
//       count: 1669,
//     },
//   ],
// };

// // 别名
// const { code: codefdgfdsg, msg1, data } = msg;
// if (codefdgfdsg == 200) {
//   console.log("dsfdg");
//   // for (let i = 0; i < data.length; i++) {
//   //   li.innerHtml = `<div>${data[i].id}</div>`;
//   // }
// }

// const person = {
//   name: "Charlie",
//   address: {
//     city: "San Francisco",
//     country: "USA",
//   },
// };
// const {
//   address: { city, country },
// } = person;
// // console.log(address); // 报错
// console.log(city); // San Francisco
// console.log(country); // USA

// const user = {
//   name: "Dave",
// };

// const { name = "aa", age = 20 } = user;
// console.log(name); // Dave
// console.log(age); // 20 (默认值)

// let a = "?a=1&b=2&c=3&d=4";
// let b = a ? a.slice(1) : "";
// console.log(b);
// let arr = b.split("&");
// console.log(arr);
// let obj = {};
// for (let i = 0; i < arr.length; i++) {
//   let arr1 = arr[i].split("=");
//   console.log(arr1);
//   obj[arr1[0]] = arr1[1];
//   // obj.arr1[0] = arr1; // 报错，键为变量时只能通过中括号形式赋值
// }
// console.log(obj);

// let obj1 = {
//   a: 1,
//   b: 2,
// };

// obj["a"] = 3;

// 定义函数
// function foo() {
//   this.aa = 1;
//   console.log("通过 new 也能调⽤函数...");
//   return "1111";
// }

// class foo {
//   constructor(a) {
//     this.aa = a;
//     console.log("通过 new 也能调⽤函数...");
//   }
// }

// class People {
//   constructor(name, age) {
//     this.name = name;
//     this.age = age;
//     console.log("通过 new 也能调⽤函数...");
//   }
// }

// // 调⽤函数
// console.log(new People("张三", 18));
// console.log(new People("李四", 16));

// // 构造函数
// function Person() {
//   // 构造函数内部的 this 就是实例对象
//   // 实例对象中动态添加属性
//   this.name = "⼩明";
//   // 实例对象动态添加⽅法
//   this.sayHi = function () {
//     console.log("⼤家好~");
//   };
// }

// // 实例化，p1 是实例对象
// // p1 实际就是 构造函数内部的 this
// const p1 = new Person();
// console.log(p1);
// console.log(p1.name); // 访问实例属性
// p1.sayHi(); // 调⽤实例⽅法

// 第一种写法
// function Computer(window, screen) {
//   this.window = window;
//   this.screen = screen;
//   this.show = function () {
//     console.log(`这个电脑的操作系统是${this.window}, 屏幕是${this.screen}`);
//   };
// }

// const p = new Computer("win10", 1440);
// p.show();

// // 第二种写法
// function Computer1() {
//   this.show = function () {
//     console.log(`这个电脑的操作系统是${this.window}, 屏幕是${this.screen}`);
//   };
// }

// const p1 = new Computer1();
// p1.window = "win10";
// p1.screen = 1440;
// p1.show();

// // 第三种写法
// class Computer2 {
//   constructor(window, screen) {
//     this.window = window;
//     this.screen = screen;
//   }
//   show() {
//     console.log(`这个电脑的操作系统是${this.window}, 屏幕是${this.screen}`);
//   }
// }

// const p2 = new Computer2("win10", 1440);
// p2.show();

// class MyClass {
//   constructor(a, b) {
//     this.a = a;
//     this.b = b;
//   }

//   add() {
//     return this.a + this.b;
//   }

//   minus() {
//     return this.a - this.b;
//   }
// }

// let obj = new MyClass(10, 20);
// // let objaa = new MyClass(50, 50);
// console.log(obj.add());
// console.log(obj.minus());

// function MyClass1(a, b) {
//   this.a = a;
//   this.b = b;
//   this.add = function () {
//     return this.a + this.b;
//   };
//   this.minus = () => this.a - this.b;
// }

// let obj1 = new MyClass1(10, 20);
// console.log(obj1.add());
// console.log(obj1.minus());

// function MyClass2() {
//   this.add = function () {
//     return this.a + this.b;
//   };
//   this.minus = () => this.a - this.b;
// }

// let obj2 = new MyClass2();
// obj2.a = 10;
// obj2.b = 20;
// console.log(obj2.add());
// console.log(obj2.minus());

// 构造函数
// function Person(name, age) {
//   // 省略实例成员
//   // this.eyes = Person.eyes;
// }
// // 静态属性（属于类，不属于实例化后的属性）
// Person.eyes = 2;
// Person.arms = 2;
// // 静态⽅法
// Person.walk = function () {
//   console.log("^_^⼈都会⾛路...");
//   // this 指向 Person
//   console.log(this.eyes);
// };
// const p = new Person();
// p.eyes = Person.eyes;

// console.log(p);

// class Person1 {
//   static a = 0;
// }

// const p1 = new Person1();
// p1.a = Person1.a;
// console.log(p1);

// const user = new Object({ name: "⼩明", age: 15 });
// // // const user = {name: '⼩明', age: 15}
// // console.log(user);

// let student = { name: "杜⼦腾", age: 21 };
// // 对象语法简写
// let name = "⼩红";
// let people = {
//   // 相当于 name: name
//   name,
//   // 相当于 walk: function () {}
//   walk() {
//     console.log("⼈都要⾛路...");
//   },
// };
// // console.log(people);
// console.log(student.constructor);
// console.log(user.constructor);
// console.log(student instanceof Object); // true

// console.log(Object.keys(people));

// let arr = new Array(5, 7, 8); // [5,7,8]
// let arr1 = arr.concat([7, 4]);
// console.log(arr1);
// console.log(arr);
// for(let i = 0; i<arr.length; i++) {
//  console.log(i, arr[i])
// }
// arr.forEach((item, index, arr) => {
//   console.log(item, index, arr);
//   // 不生效，forEach不能跳出循环
//   if (index == 1) {
//     return;
//   }
// });

// class HH {
//   constructor() {
//     this.name = "lll";
//     this.age = "90";
//     this.fun = () => {};
//   }
// }

// HH.a = "ll";

// function Kk() {}

// let obj = new HH();
// obj.name = "111";
// console.log(obj);

// let obj = {
//   a: 1,
//   b: 2,
// };

// console.log(Object.entries(obj)); // [[a, 1], [b,2]]
// console.log(Object.keys(obj));
// console.log(Object.values(obj));

// [1,2].concat([1,2])
// let newObj = Object.assign({ a: 2, c: 4 }, obj); // 合并多个对象，生成一个新的对象
// obj.a = 2;
// console.log(newObj, obj);

// let newobj1 = obj;  // 对象或者数组直接赋值，改变赋值与被赋值的内容都会相互同步改变
// obj.a = 2;
// console.log(newobj1, obj);

// let a = 1;
// let b = a;
// a = 2;
// console.log(a, b);

// function aa(obj) {
//   let arr = [];
//   for (key in obj) {
//     // console.log(key);
//     // console.log(obj[key]);
//     arr.push([key, obj[key]]);
//   }
//   return arr;
// }

// console.log(aa(obj));

// let arr = [1, 2, 3, 4, 6];
// // 等同于for循环
// arr.forEach((a, b, c) => {
//   console.log(a, b, c);
// });
// arr.forEach(function(item, index, arr){

// })
// let arr1 = arr.map((item,index, arr)=>{
//   return 'a'
// })
// 1, 0, [1, 2, 3];
// 2, 1, [1, 2, 3];
// 3, 2, [1, 2, 3];
// 合并数组，生成一个新数组
// console.log([1, 2, 3].concat([1, 2]));

// let str = "abcsdgdsgfdhgdfgh";
// // 首字母大写
// let str1 = str.charAt(0).toUpperCase() + str.slice(1);
// console.log(str1);
// console.log("hello world".includes("hello"));
// const str = "The rain in SPAIN stays mainly in the plain";
// const result = str.match(/ain/g);
// console.log(result);

// console.log(Number("abc123"));
// let num = 3.1465926;
// let str = num.toFixed(2); // 保留⼩数点后2位，会四舍五入
// console.log(str); // 输出 "3.14"

// document.getElementById("a");
// document.querySelector("#a"); // css语法
// document.querySelectorAll("ul li")[2];
// window.open("home.html"); // 新打开一个窗口
// location.href = "home.html"; // 在同一个窗口下跳转

// console.log(document.querySelector("#div").offsetWidth); // 包含边框
// console.log(document.querySelector("#div").clientWidth); // 不含边框

// console.log("hello hello Hello".replace(/hello/, "hi")); // 替换第一个符合规则内容
// console.log("hello hello Hello".replace(/hello/g, "hi")); // global 全局替换（区分大小写）
// console.log("hello hello Hello".replaceAll("hello", "hi")); // 全局替换（区分大小写）
// console.log("hello hello Hello".replace(/hello/gi, "hi")); // 全局替换（区分大小写）
// let arr = [1, 2, 3, 4, 5, 6].filter((a, b) => b > 2);  // [4,5,6]
// console.log(arr);
// console.log("hello world".substring(2, 7)); // 从哪里开始截取到哪里结束，包含开始不包含结束

// (function fun() {

// })()
// function fun() {

// }
// fun()
// const fun = () => {

// }

// setInterval(function() {
//   console.log('a')
// }, 1000);

// ["a", "b", "c"].join(','); // split/join
// a、b、c

// function Fun() {
//   this.name = "aa";
// }
// Fun.member = "dgdfh";
// let obj = new Fun();
// console.log(obj.member);

// console.log(typeof undefined);

// try {
//   // let a = 1;
//   const a = 1;
//   a = 2;
// } catch (e) {
//   console.log(e);
// } finally {
//   console.log("111");
// }

// function fun() {
//   // console.log(arguments);
//   let arr = [];
//   for (let i = 0; i < arguments.length; i++) {
//     if (arguments[i] % 2 !== 0) {
//       arr.push(arguments[i]);
//     }
//   }
//   return arr;
// }
// console.log(fun(1, 2, 3, 4, 5));

// const fun1 = (...args) => {
//   // return args.filter((item) => item % 2 != 0);
//   let arr = [];
//   for (let i = 0; i < args.length; i++) {
//     if (args[i] % 2 !== 0) {
//       arr.push(args[i]);
//     }
//   }
//   return arr;
// };
// console.log(fun1(1, 2, 3, 4, 5));

// function Fun(name, age) {
//   this.name = name;
//   this.age = age;
//   this.detail = function () {
//     console.log(`我叫${this.name}，今年${this.age}岁。`);
//   };
// }

// let obj = new Fun("张三", 18);
// obj.detail();
// Fun.a = "张三";
// Fun.b = 18;
// Fun.show = () => {
//   console.log(`我叫${Fun.a}，今年${Fun.b}岁。`);
// };
// Fun.show();

// class Fun1 {
//   constructor(name, age) {
//     this.name = name;
//     this.age = age;
//     this.detail = () => {
//       console.log(`我叫${this.name}，今年${this.age}岁。`);
//     };
//   }
// }

// let obj1 = new Fun1("张三", 18);
// obj1.detail();

// function Fun() {}
// console.log(Fun.prototype);

// function Person() {
//   // 此处定义同名⽅法 sayHi
//   // this.sayHi = function () {
//   //   console.log("嗨!");
//   // };
//   this.show = function () {
//     console.log("111");
//   };
// }

// // // 为构造函数的原型对象添加⽅法
// Person.prototype.sayHi = function () {
//   console.log("Hi~");
// };
// // // 实例化
// let p1 = new Person();
// p1.sayHi(); // 输出结果为 Hi~
// // p1.show = function () {
// //   console.log("222");
// // };
// let p2 = new Person();
// // p2.sayHi();
// // p2.show();
// Person.prototype.sayHi = function () {
//   console.log("Hi1111~");
// };
// p1.sayHi();
// p2.sayHi();

// function Person() {
//   // 此处定义同名⽅法 sayHi
//   this.sayHi = function () {
//     console.log("嗨!" + this.name);
//   };
// }
// // 为构造函数的原型对象添加⽅法
// Person.prototype.sayHi = function () {
//   console.log("Hi~" + this.name);
// };
// // 在构造函数的原型对象上添加属性
// Person.prototype.name = "⼩明";
// let p1 = new Person();
// p1.name = "小张";
// p1.sayHi(); // 输出结果为 嗨!

// let p2 = new Person();
// p2.sayHi();

// console.log(Object.getPrototypeOf(p2));
// console.log(p2.__proto__);

// Person.prototype = {
//   constructor: Person, // 让constructor重新指向构造函数
//   method1: () => {},
//   method2: () => {},
// };

// console.log(Person.prototype);

// 构造函数 new 出来的对象 结构⼀样，但是对象不⼀样
// function Person() {
//   this.eyes = 2;
//   this.head = 1;
// }
// // console.log(new Person)
// // ⼥⼈ 构造函数 继承 想要 继承 Person
// function Woman() {}
// // Woman 通过原型来继承 Person
// // ⽗构造函数（⽗类） ⼦构造函数（⼦类）
// // ⼦类的原型 = new ⽗类
// Woman.prototype = new Person(); // {eyes: 2, head: 1}
// // 指回原来的构造函数
// Woman.prototype.constructor = Woman;
// // 给⼥⼈添加⼀个⽅法 ⽣孩⼦
// Woman.prototype.baby = function () {
//   console.log("宝⻉");
// };
// const red = new Woman();
// console.log(red.eyes);
// // console.log(Woman.prototype)
// // 男⼈ 构造函数 继承 想要 继承 Person
// function Man() {}
// // 通过 原型继承 Person
// Man.prototype = new Person();
// Man.prototype.constructor = Man;
// const p = new Man();
// console.log(p);

// class P {
//   constructor(name, age) {
//     this.name = name;
//     this.age = age;
//   }
// }

// // class继承机制
// class P1 extends P {
//   constructor(name, age) {
//     super(name, age);
//   }
// }

// let obj = new P1("小明", 19);
// console.log(obj);

// function Objetc() {}
// console.log(Object.prototype);
// console.log(Object.prototype.__proto__);
// function Person() {}
// const ldh = new Person();
// console.log(ldh.__proto__ === Person.prototype);
// console.log(Person.prototype.__proto__ === Object.prototype);
// console.log(ldh instanceof Person);
// console.log(ldh instanceof Object);
// console.log(ldh instanceof Array);
// console.log([1, 2, 3] instanceof Array);
// console.log(Array instanceof Object);

// function A(a, b) {
//   this.a = a;
//   this.b = b;
// }

// function B() {}

// B.prototype = new A(1, 2);
// B.prototype.constructor = B;
// B.prototype.add = function () {
//   return this.a + this.b;
// };
// let obj = new B();
// console.log(obj.add());

// class AA {
//   constructor(a, b) {
//     this.a = a;
//     this.b = b;
//   }
// }
// class BB extends AA {
//   // constructor(a, b) {
//   //   super(a, b);
//   // }
// }

// let obj1 = new BB(1, 2);
// console.log(obj1);

// 扩展运算符
// function sum(x, y, z) {
//   return x + y + z;
// }
// const numbers = [1, 2, 3];
// const result = sum(...numbers); // 相当于调⽤ sum(1, 2, 3)
// console.log(result);

// const first = [1, 2];
// const second = [3, 4];
// const combined = [...first, ...second]; // 结果为 [1, 2, 3, 4]
// console.log(combined);

// function push(array, ...items) {
//   items.forEach((item) => array.push(item));
// }
// const stack = [];
// push(stack, "a", "b", "c", "e", "f"); // stack 现在为 ['a', 'b', 'c']
// console.log(stack);

// const defaults = { food: "pasta", price: 5, vegan: false };
// const order = { ...defaults, price: 10, vegan: true };
// console.log(order);

// const obj1 = { a: 1, b: 2 };
// const obj2 = { b: 3, c: 4 };
// const combined = { ...obj2, ...obj1 };
// console.log(combined);

// console.log(123456789012342324325);

// let arr = [1, 2, 3];
// let arr1 = [...arr];
// console.log(arr, arr1);
// arr[0] = 2;
// console.log(arr, arr1);

// 浅拷贝：对于引用类型的数据，拷贝出来的内容做出改变时会影响原来的内容
// 深拷贝：对于引用类型的数据，拷贝出来的内容做出改变时不会影响原来的内容
// const original = [{ a: 1 }, { a: 2 }];
// const copy = [...original]; // copy 为 [1, 2, 3] 浅拷贝
// console.log(original, copy);

// copy[0].a = 2;
// console.log(original, copy);

// let obj1 = { a: { b: 1 } };
// let obj2 = { c: { d: 2 } };
// let obj = Object.assign(obj1, obj2); // 等同于let obj = {...obj1, ...obj2}
// obj1.a.b = 2;
// console.log(obj);
// let arr1 = [{ b: 1 }, { b: 2 }];
// let arr2 = [{ b: 3 }, { b: 4 }];
// let arr3 = arr1.concat(arr2); // 等同于let arr3 = [...arr1, ...arr2]
// arr1[0].b = 8;
// console.log(arr3);

// 递归：当前函数里面调自己
// function deepCopy(obj) {
//   // 检查 obj 是否为对象或数组，并且不为 null
//   if (typeof obj !== "object" || obj === null) {
//     return obj; // 如果不是对象或数组（⽐如是基本类型），直接返回它的值
//   }
//   // 根据 obj 是数组还是对象来初始化 result，保持类型⼀致
//   let result = Array.isArray(obj) ? [] : {};
//   // 遍历 obj 的每个属性
//   for (let key in obj) {
//     if (obj.hasOwnProperty(key)) {
//       // 递归调⽤ deepCopy 函数，确保嵌套对象或数组也能被深拷⻉
//       result[key] = deepCopy(obj[key]);
//     }
//   }
//   // 返回深拷⻉的对象或数组
//   return result;
// }

// let a = 1;
// console.log(deepCopy(a));

// let obj = {
//   a: {
//     b: {
//       c: 1,
//     },
//   },
//   aa: 1,
// };

// let obj1 = deepCopy(obj); // 深拷贝
// let obj1 = structuredClone(obj); // 深拷贝
// let obj1 = obj; //浅拷贝
// obj.a.b.c = 4;
// console.log(obj, obj1);

// const obj = {
//   uname: "小红",
//   age: 18,
//   hobby: ["乒乓球", "⾜球"],
//   family: {
//     baby: "小红",
//   },
// };
// const o = _.cloneDeep(obj);
// console.log(o);
// o.family.baby = "小绿";
// console.log(obj);

// let arr = [
//   {
//     title: "a",
//     children: [
//       {
//         title: "b",
//         children: [
//           {
//             title: "c",
//             children: [],
//           },
//         ],
//       },
//       {
//         title: "b1",
//         children: [
//           {
//             title: "c1",
//             children: [],
//           },
//         ],
//       },
//     ],
//   },
//   {
//     title: "a1",
//     children: [
//       {
//         title: "b1",
//         children: [
//           {
//             title: "c1",
//             children: [],
//           },
//         ],
//       },
//     ],
//   },
// ];

// function fun(arr) {
//   // debugger;
//   console.log(arr[0].title);
//   if (arr[0].children && arr[0].children.length) {
//     fun(arr[0].children);
//   }
// }

// fun(arr);

// function fun(arr) {
//   let arr1 = [];
//   for (item of arr) {
//     arr1.push(item.title);
//     if (item.children.length) {
//       arr1.push(...fun(item.children));
//     }
//   }
//   return arr1;
// }

// console.log(fun(arr));

// let arr1 = [];
// function fun(arr) {
//   arr.forEach((element) => {
//     arr1.push(element.title);
//     if (element.children && element.children.length) {
//       fun(element.children);
//     }
//   });
// }

// fun(arr);
// console.log(arr1);

// let obj1 = {
//   a: 1,
//   b: [1, 2, 3],
//   c: function () {},
//   d: undefined,
// };
// let obj2 = JSON.parse(JSON.stringify(obj1));
// console.log(obj2); // 输出 undefined，因为函数不能被 JSON.stringify() 处理
// console.log(obj2.d); // 输出 undefined，因为 undefined 不能被 JSON.stringify() 处理

// const obj = {
//   name: "Kimi",
//   age: 1,
//   details: {
//     hobbies: ["coding", "reading"],
//   },
// };
// const jsonString = JSON.stringify(obj);
// console.log(jsonString); // 输出: {"name":"Kimi","age":1,"details":{"hobbies":["coding","reading"]}}
// let str = `{"name":"Kimi","age":1,"details":{"hobbies":["coding","reading"]}}`;

// const obj = { name: "Kimi", age: 1, secret: "hidden" };
// function replacer(key, value) {
//   if (key === "secret") {
//     return undefined; // 从序列化中排除 secret 属性
//   }
//   return value;
// }
// const jsonString = JSON.stringify(obj, replacer);
// console.log(jsonString); // 输出: {"name":"Kimi","age":1}

// 异常处理
// throw "An error occurred"; // 抛出⼀个字符串作为异常
// throw 42; // 抛出⼀个数字作为异常
// throw new Error("Something went wrong"); // 抛出⼀个 Error 对象作为异常
// let error = new Error("Invalid operation");
// throw error; // 抛出⼀个 Error 对象

// try {
//   // 可能会抛出异常的代码
//   JSON.parse('"a": 1');
// } catch (error) {
//   // 处理异常的代码
//   console.log(error);
// } finally {
//   // 总是会执⾏的代码
//   console.log("dfdg");
// }

// function validateAge(age) {
//   if (typeof age !== "number" || age <= 0) {
//     throw new Error("Invalid age provided");
//   }
//   return true;
// }
// try {
//   let age = parseInt(prompt("Enter your age:"));
//   validateAge(age);
//   console.log("Age is valid");
// } catch (error) {
//   console.error("Error:", error.message);
// } finally {
//   console.log("Age validation complete");
// }

// // 普通函数
// function sayHi() {
//   console.log(this);
// }
// // 函数表达式
// const sayHello = function () {
//   console.log(this);
// };
// // 函数的调⽤⽅式决定了 this 的值
// sayHi(); // window
// window.sayHi();

// 普通对象
// const user = {
//   name: "⼩明",
//   // 该箭头函数中的 this 为函数声明环境中 this ⼀致
//   walk: () => {
//     console.log(this);
//   },

//   sleep: function () {
//     let str = "hello";
//     console.log(this);
//     let fn = () => {
//       console.log(str);
//       console.log(this); // 该箭头函数中的 this 与 sleep 中的 this ⼀致
//     };
//     // 调⽤箭头函数
//     fn();
//   },
// };
// // 动态添加⽅法
// user.sayHi = sayHi;

// // 函数调⽤
// user.sayHi();
// user.sleep();
// user.walk();

// DOM 节点
// const btn = document.querySelector(".btn");
// // 箭头函数 此时 this 指向了 window
// btn.addEventListener("click", () => {
//   console.log(this);
// });
// // 普通函数 此时 this 指向了 DOM 对象
// btn.addEventListener("click", function () {
//   console.log(this);
// });

// function Person() {}
// // 原型对像上添加了箭头函数
// Person.prototype.walk = () => {
//   console.log("⼈都要⾛路...");
//   console.log(this); // window
// };
// const p1 = new Person();
// p1.walk();

// 普通函数
// function sayHi(name, age) {
//   // console.log(this);
//   console.log(this, name, age);
// }

// let user = {
//   name: "⼩明",
//   age: 18,
// };

// let student = {
//   name: "⼩红",
//   age: 16,
// };

// // 立即调⽤函数并指定 this 的值（第一个参数是this指针的指向，第二个以后的参数都是对应函数的传参）
// sayHi.call(user, "小芳", 20); // this 值为 user
// sayHi.call(student); // this 值为 student
// // apply的第一个参数是this指针的指向，第二个参数是数组，用来装函数的具体传参
// sayHi.apply(user, ["晓东", 23]); // this 值为 user
// sayHi.apply(student); // this 值为 student
// let sayHello = sayHi.bind(user);
// // 调⽤使⽤ bind 创建的新函数
// sayHello("小芳", 20);

// // 求和函数
// function counter(x, y) {
//   return x + y;
// }
// // 调⽤ counter 函数，并传⼊参数
// let result = counter.call(null, 5, 10);

// /**
//  * @desc 函数防抖
//  * @param func 回调函数
//  * @param delay 延迟执⾏毫秒数
//  */
// function debounce(func, delay) {
//   let timer; // 定时器
//   return function () {
//     let context = this; // 记录 this 值,防⽌在回调函数中丢失
//     let args = arguments; // 函数参数
//     //如果定时器存在，则清除定时器(如果没有,也没必要进⾏处理)
//     timer ? clearTimeout(timer) : null;
//     timer = setTimeout(() => {
//       // 防⽌ this 值变为 window
//       func.apply(context, args);
//     }, delay);
//   };
// }

// /**
//  * @desc 函数防抖
//  * @param func 回调函数
//  * @param delay 延迟执⾏毫秒数
//  */
// function _debounce(func, delay) {
//   let timer; // 定时器
//   return function () {
//     let context = this; // 记录 this 值,防⽌在回调函数中丢失
//     let args = arguments; // 函数参数

//     // 标识是否⽴即执⾏
//     let isImmediately = !timer;
//     //如果定时器存在，则清除定时器(如果没有,也没必要进⾏处理)
//     timer ? clearTimeout(timer) : null;
//     timer = setTimeout(() => {
//       timer = null;
//     }, delay);

//     // isImmediately 为 true 则 执⾏函数(即⾸次触发事件)
//     isImmediately ? func.apply(context, args) : null;
//   };
// }

// /**
//  * @desc 函数节流
//  * @param func 回调函数
//  * @param limit 时间限制
//  */
// const throttle = (func, limit) => {
//   let inThrottle; // 是否处于节流限制时间内
//   return function () {
//     const context = this;
//     const args = arguments;
//     // 跳出时间限制
//     if (!inThrottle) {
//       func.apply(context, args); // 执⾏回调
//       inThrottle = true;
//       // 开启定时器计时
//       setTimeout(() => (inThrottle = false), limit);
//     }
//   };
// };

// /**
//  * @desc 函数节流
//  * @param func 回调函数
//  * @param limit 时间限制
//  */
// function _throttle(func, limit) {
//   //上次执⾏时间
//   let previous = 0;
//   return function () {
//     //当前时间
//     let now = Date.now();
//     let context = this;
//     let args = arguments;

//     // 若当前时间-上次执⾏时间⼤于时间限制
//     if (now - previous > limit) {
//       func.apply(context, args);
//       previous = now;
//     }
//   };
// }

// document.getElementById("div").addEventListener(
//   "click",
//   // 不加防抖
//   // ()=>{
//   //   console.log("ddd");
//   // }
//   // 加防抖，延迟多少秒后执行，在此期间只执行一次
//   // debounce(function () {
//   //   console.log("ddd");
//   // }, 1000)
//   // 加防抖，立即执行，延迟多少再执行第二次，在此期间只执行一次
//   // _debounce(function () {
//   //   console.log("ddd");
//   // }, 1000)
//   // 用loadash第三方库实现防抖机制
//   // _.debounce(function () {
//   //   console.log("ddd");
//   // }, 1000)
//   throttle(function () {
//     console.log("ddd");
//   }, 1000)
// );

// function fun(n) {
//   if (n == 0) {
//     return 1;
//   }
//   return n * fun(n - 1);
// }

// console.log(fun(8));

// 第七次考试
// const obj1 = { a: 1, b: 2 };
// const obj2 = { b: 3, c: 4 };
// const obj = { ...obj1, ...obj2 };
// console.log(obj);

// let arr1 = [{ a: 1 }];
// let arr2 = [{ a: 2 }];
// let arr = [{ ...arr1[0], ...arr2[0] }];
// console.log(arr);

// function Fun() {
//   this.fun2 = function() {

//   }
// }
// Fun.prototype.fun = function () {
//   console.log(111);
// };

// Fun.fun1 = () => {

// }

// let F = new Fun();
// Fun.prototype.fun = function () {
//   console.log("aaaa");
// };
// F.fun();
// // let F1 = new Fun();
// F1.fun();

// function Fun() {
//   this.a = 1; // 成员变量
//   this.fun = function () {
//     console.log(111);
//   };
// }

// class C {
//   constructor(a, b) {
//     this.a = a;
//     this.b = b;
//   }
// }

// Fun.prototype.fun1 = () => {
//   console.log(222);
// };

// let f = new Fun();
// console.log(f.a);
// f.fun();
// f.fun1();

// let obj1 = { a: { b: 1 } };
// // let obj = { ...obj1 };
// // obj1.a.b = 2;

// let obj = structuredClone(obj1);
// // let obj = JSON.parse(JSON.stringify(obj1));
// obj1.a.b = 2;

// console.log(obj, obj1);

// function fun(a, b) {
//   console.log(this.a, a, b);
// }
// let user = { a: "a", b: "b" };
// fun.call(user, ["c", "d"], "uuu"); // a, ["c", "d"], undefined
// fun.apply(user, ["c", "d"]); // a, c, d
// const fun1 = fun.bind(user);
// fun1(1, 2); // a, 1, 2

// console.log((12.358).toFixed(2));

// get请求
// location.href = "js-demo3.html?a=1&b=2";
// console.log([1, 3, 5, 2, 6].reverse());
// console.log(Array instanceof Object);

// const f = (...arguments) => {
//   console.log(arguments);
// };

// f(1, 2);

function Fun(a, b) {
  this.a = a;
  this.b = b;
}

function F1() {}
F1.prototype = new Fun(1, 2);
F1.prototype.contructor = F1;
F1.prototype.bb = function () {
  console.log(this.a);
};
let obj = new F1();
obj.bb();

class A {
  constructor(a, b) {
    this.a = a;
    this.b = b;
  }
}

class B extends A {
  constructor(a, b) {
    super(a, b);
    this.bb = function () {
      console.log(this.a);
    };
  }
}

let obj1 = new B(1, 2);
obj1.bb();
